--[[
接收：
1.只接收海康 电警相机 SDK传来的图片流
2.初始化，校验参数
3.获取文件流form_res
4.校验队列 
5.解析data流，获取fname，解析fname，存入表中     ---up_utils.
（若是小图，延时缓存）
  ngx.sleep(0.05) --传递第一张小图时先sleep 50ms,确保先缓存第一张大图  
6.md5校验
7.存入storage
-----------违章单独存入mongodb
打包：
db_data1 = {}   -----用于打包
1.1设置小图   key1 = db_data.sbbh.."_"..db_data.txxh.."_1_plate"
1.2设置大图   key2 = db_data.sbbh.."_"..db_data.txxh.."_1"
2 判断是否有车牌（hphm）        
  2.1 没有车牌，该车只有一张图片，直接打包   ----up_utils.dj_pack_1
  2.2 有车牌，判断是大图还是小图
    2.2.1 是小图              ------up_utils.dj_pack_3
      2.2.1.1 大图存在，两张一起打包
      2.2.1.2 大图不存在，单独打包
    2.2.2 是大图             -------up_utils.dj_pack_2
      2.2.2.1 与大图key相同的缓存是否存在，存在则打包，清除缓存
      2.2.2.2 缓存本张大图
3.db_data1若为空表，安全退出
（可能出现的异常情况：1.车牌图先于大图上传，结果：车牌图单独打包，大图等待至下轮打包
                2.车牌图未上传，大图正常上传，结果：大图等待至下轮打包
                3.大图未上传，车牌图正常上传，结果：车牌图直接打包）      
存储：
根据是否违章
插入mongodb记录数据
插入redis
          违章进入违章队列 
          正常进入正常队列                   
--]]

local vssid                    = "test"
local utils                    = require "gcs.utils"
local err_utils                = require "gcs.upload.error_utils"
local red_method               = require "gcs.list.method"
local mongo_method             = require "gcs.mongodb.method"
local storage                  = require "resty.gcsdfs.storage"              --加载storage �?
local multipart                = require "resty.gcsdfs.multipart"
local up_utils                 = require "gcs.upload.upload_utils"
local db_method                = require "gcs.db.method"
local cjson                    = require "cjson"
local resty_uuid               = require "resty.uuid"

--取时间最后2位 00-59
local sec = os.date("%S",ngx.time())
--取小时前2位 00-23
local hour = os.date("%H",ngx.time())
--取日期后2位00-31
local today = ngx.today()
local day = string.sub(today,-2)
---取月份
local mon = os.date("%Y%m",ngx.time())   --2014-08


--------------------------------初始化-------------

local format = "jpg"
local model = "upload_hkdj"
local remote_ip                = ngx.var.remote_addr

local config_table = ngx.shared.gcs_config   --声明ngx.shared.gcs_config
local ipshine_table = ngx.shared.gcs_ipshine   --声明ngx.shared.gcs_ipshine
local md5_check = ngx.shared.md5_check

local form_timeout = config_table:get("p_form_timeout")
local form_chunk_size = config_table:get("p_form_chunk_size")
local cjson_group = config_table:get("p_group_table")
local store_connect_timeout = config_table:get("p_store_connect_timeout")
local store_keep_timeout = config_table:get("p_store_keep_timeout")
local store_keep_count = config_table:get("p_store_keep_count")
local cjson_queue              = config_table:get("p_queue")



--获得客户端ip

-----------校验参数
local tb_parameters = {}
tb_parameters.form_timeout = form_timeout
tb_parameters.form_chunk_size = form_chunk_size
tb_parameters.store_connect_timeout = store_connect_timeout
tb_parameters.store_keep_timeout = store_keep_timeout
tb_parameters.store_keep_count = store_keep_count
tb_parameters.cjson_group = cjson_group
local check_parameters = {
  "store_keep_timeout",              "store_keep_count"    
}

local res,err,err_no = utils.check_parameter(tb_parameters,check_parameters)
err_utils.check_res(res,model,vssid,err,err_no,nil)

utils.gcs_log("debug",model .."second_line upload,check_parameter is ok")


------------3.获取文件流form_res

local form = multipart:new(form_timeout,form_chunk_size)
local form_res,err,err_no = up_utils.get_form_res(form)
utils.gcs_log("error"," form_res content : " ..cjson.encode(form_res))
local form_res = err_utils.check_res(form_res,model,vssid,err,err_no,nil)
---校验form_res中的字段是否存在?
local res,err,err_no = up_utils.check_form_res(form_res)
err_utils.check_res(res,model,vssid,err,err_no,nil)
utils.gcs_log("debug",model .."check form_res is ok")

------------------------校验队列

local tb_queue,err,err_no = up_utils.get_queue(cjson_queue,remote_ip)  ---获取队列信息
local tb_queue = err_utils.check_res(tb_queue,model,vssid,err,err_no,nil)
utils.gcs_log("debug",model .."check queue is ok")

-----------5.解析data流，获取fname，解析fname，存入表中
local str_data = form_res.data.value
local fpath,fname = up_utils.get_filename(str_data)
fname = up_utils.createIconv("gbk","utf-8",fname)    --将gbk转成utf-8
local db_data = {} --- 打包时只需要重定义一次
local db_data = up_utils.analysis_fname(fname)
db_data.size = form_res.gfile1.file_size
db_data.md5 = form_res.gfile1.md5
db_data.zpzs=1
db_data.lx="dj"
db_data.wfxwdm=db_data.wfxwdmdj
db_data.wfxwdmkk=nil
db_data.wfxwdmdj=nil
local tpmc={db_data.lkbh,db_data.time,db_data.txxh,db_data.zpzs,
  db_data.zpxh,db_data.hphm,db_data.hpys,db_data.xssd,db_data.xsfx,
  db_data.cd,db_data.wfxwdm,db_data.hpsztpzb,db_data.csys,db_data.clpp,db_data.sbbh} 
db_data.tpmc=table.concat(tpmc,"-") 

if tonumber(db_data.zpxh) == 2 then
  utils.gcs_log("error","抓拍序号为3")
  ngx.exit(200)
end
---------------------------------------------------------
--校验MD5


local kkk=string.find(str_data,"Plate")
if db_data.wfxwdm ~= "00000" then          ---违章
    if kkk then       ------违章小图
        local new_md5 = ngx.encode_base64(db_data.md5)
        if md5_check:get(new_md5) then  ---发现有md5对应的值,属于重复提交          
          ngx.exit(200)       ---直接退出
        else       ----发型现没有md5对应的值,直接缓存md5,用于下次校验
          md5_check:set(new_md5,1)    
        end
    else            ------违章大图
        if md5_check:get(db_data.md5) then  ---发现有md5对应的值,属于重复提交
           utils.gcs_log("error","违章车牌大图,md5相同:")
            ngx.exit(200)       ---直接退出
        else       ----发型现没有md5对应的值,直接缓存md5,用于下次校验
            md5_check:set(db_data.md5,1)
        end
    end
else
    if md5_check:get(db_data.md5) then  ---发现有md5对应的值,属于重复提交
    utils.gcs_log("debug",model .."重复提交")
      ngx.exit(200)       ---直接退出
    else       ----发型现没有md5对应的值,直接缓存md5,用于下次校验
      md5_check:set(db_data.md5,1)
    end
end





---------------------------------------------
--存入storage
local st_res=""
if db_data.wfxwdm~="00000" then 
    st_res=up_utils.get_storage(cjson_group)
else
    st_res = up_utils.get_storage(cjson_group)
end
local tb_value = {
  timeout = store_connect_timeout,
  keep_timeout = store_keep_timeout,
  keep_count = store_keep_count
}
local gfile,err,err_no = up_utils.save_storage(form_res,st_res,tb_value,format)
local gfile = err_utils.check_res(gfile,model,vssid,err,err_no,db_data.md5)
utils.gcs_log("debug",model .."存入mongodb成功")
db_data.gfile = gfile
db_data.str_res = cjson.encode(st_res)
db_data.server_ip = tb_queue.server_ip

utils.gcs_log("debug",model .."get pic info is ok")
utils.gcs_log("debug",db_data.sbbh.."-"..db_data.txxh.."-"..db_data.zpxh.."-"..db_data.md5..","..db_data.gfile.."-"..db_data.time)


--------------------------------------------------------
--key的设置
local key2=db_data.sbbh .."_" ..db_data.txxh .."_1"  --第一张大图的key
local key1=db_data.sbbh .."_" ..db_data.txxh .."_1_plate" --车牌的key
  
local db_data1={}
local mongo_table_name1=""  --mongodb表名
local list=""  --队列名
local numlist="" --违章计数

-----------------------------------------------------------
--打包
--
local key=string.find(str_data,"Plate") and key1 or key2
local res1,code,status=up_utils.pack_checkself(key,db_data)
err_utils.check_res(res1,model,vssid,err,err_no,db_data.md5)
if code==0 then --缓存存在
    if status==0 then --传过来的数据是历史数据打包传过来的图片
        db_data1=up_utils.pack_kk2(db_data)
    else--缓存数据是历史数据打包缓存数据
        db_data1=up_utils.pack_kk2(res1)
    end
     utils.gcs_log("debug",model .."打包结束，存储开始")
    local time1=string.sub(db_data1.time1,1,6)
    local mongo_table_name = "gcxx_" ..time1
    local mongo_table_namewz = "wzgcxx"
    if db_data1.wfxwdm~="00000" then
        mongo_table_name1=mongo_table_namewz
        list="wzlist"
        numlist="gc_wznumby"
    else 
        mongo_table_name1=mongo_table_name
        list=tb_queue.q_name  
    end   
   
    local n,res=up_utils.pack_stor(db_data1,mongo_table_name1,list)
    err_utils.check_res(n,model,vssid,err,1402,nil)
    err_utils.check_res(res,model,vssid,err,1402,nil)
    utils.gcs_log("debug",model .."存入mongodb成功，插入" ..list .."队列成功")
    
    if  numlist=="gc_wznumby"  then
        up_utils.ins_numbytime(numlist .."hour_" ,hour)--按小时计算违章过车数量
        up_utils.ins_numbytime(numlist .."day_" ,day)--按天数计算违章过车数量
        up_utils.ins_numbytime(numlist .."mon_" ,mon)--按月份计算违章过车数量
        up_utils.ins_numbytime(db_data1.lkbh .."_" ..numlist .."hour_",hour) --按小时计算路口违章过车数量
    end
    --计算流量
    up_utils.ins_numbytime(db_data1.lkbh .."_gc_numbyhour_",hour) --路口过车数量
    up_utils.ins_numbytime(db_data1.lkbh .."_gc_" ..db_data1.hpzl .."car_numbyhour_" ,hour) --按小时计算路口大型车，小型车数量
    up_utils.ins_numbytime(db_data1.lkbh .."_gc_" ..db_data1.clpz .."car_numbyhour_" ,hour)--按小时路口外地车，本地车数量
    up_utils.ins_numbytime("gc_numbyhour_" ,hour)--按小时计算过车流量
    up_utils.ins_numbytime("gc_numbyday_",day) --按天数计算过车流量
    up_utils.ins_numbytime("gc_numbymon_" ,mon)--按月份计算过车流量
    ngx.exit(200)
else--缓存不存在
    res1=db_data
end
if key==key1 then --车牌进来
   utils.gcs_log("debug","车牌进来，检查大图缓存")
   local res2,code,status=up_utils.pack_checkred(key2,key,db_data)
   err_utils.check_res(res2,model,vssid,err,err_no,db_data.md5)
   if code==0 then --大图缓存存在
      if status==0 then --是同一组
          db_data1=up_utils.pack_kk2(res2,res1)
          local tb_key={key,key2}--清除缓存
          red_method.del_data(tb_key)
          --2张打包 
      elseif status==-1 then--缓存时间大，传过来的图片是历史数据，打包传过来的图片
          db_data1=up_utils.pack_kk2(res1)
      else--缓存时间小，缓存图片是历史数据
          db_data1=up_utils.pack_kk2(res2)
      end
      
   else--缓存不存在
      utils.gcs_log("debug",model .."车牌进来，大图不存在，退出")
      ngx.exit(200)
   end
else--大图进来 
   if db_data.hphm=="无车牌" then
      db_data1=up_utils.pack_kk2(res1) 
      utils.gcs_log("debug",model .."车辆本身没有车牌，直接将自己打包")
   else--有车牌
      local res2,code,status=up_utils.pack_checkred(key1,key,db_data)
       err_utils.check_res(res2,model,vssid,err,err_no,db_data.md5)
       if code==0 then --车牌缓存存在
          if status==0 then --是同一组
              utils.gcs_log("debug",model .."车牌缓存存在并且是同一组，打包")
              db_data1=up_utils.pack_kk2(res1,res2)
              
              local tb_key={key,key1}--清除缓存
              red_method.del_data(tb_key)
              --2张打包 
          elseif status==-1 then--缓存时间大，传过来的图片是历史数据，打包传过来的图片
              db_data1=up_utils.pack_kk2(res1)
          else--缓存时间小，缓存图片是历史数据，打包缓存数据
              db_data1=up_utils.pack_kk2(res2)
          end
       else--缓存不存在
          utils.gcs_log("debug",model .."车牌不存在，退出")
          ngx.exit(200)
       end 
   end
end
local time1=string.sub(db_data1.time1,1,6)
    local mongo_table_name = "gcxx_" ..time1
    local mongo_table_namewz = "wzgcxx"
if db_data1.wfxwdm~="00000" then
    mongo_table_name1=mongo_table_namewz
    list="wzlist"
    numlist="gc_wznumby"
else 
    mongo_table_name1=mongo_table_name
    list=tb_queue.q_name  
end   
    utils.gcs_log("debug","打包结束，存储开始")
local n,res=up_utils.pack_stor(db_data1,mongo_table_name1,list)
    err_utils.check_res(n,model,vssid,err,1402,nil)
    err_utils.check_res(res,model,vssid,err,1402,nil)
    utils.gcs_log("debug",model .."存入mongodb成功，插入" ..list .."队列成功")
 if  numlist=="gc_wznumby"  then
    up_utils.ins_numbytime(numlist .."hour_" ,hour)--按小时计算违章过车数量
        up_utils.ins_numbytime(numlist .."day_" ,day)--按天数计算违章过车数量
        up_utils.ins_numbytime(numlist .."mon_" ,mon)--按月份计算违章过车数量
        up_utils.ins_numbytime(db_data1.lkbh .."_" ..numlist .."hour_",hour) --按小时计算路口违章过车数量
end
up_utils.ins_numbytime(db_data1.lkbh .."_gc_numbyhour_",hour) --路口过车数量
up_utils.ins_numbytime(db_data1.lkbh .."_gc_" ..db_data1.hpzl .."car_numbyhour_" ,hour) --按小时计算路口大型车，小型车数量
up_utils.ins_numbytime(db_data1.lkbh .."_gc_" ..db_data1.clpz .."car_numbyhour_" ,hour)--按小时路口外地车，本地车数量
up_utils.ins_numbytime("gc_numbyhour_" ,hour)--按小时计算过车流量
up_utils.ins_numbytime("gc_numbyday_",day) --按天数计算过车流量
up_utils.ins_numbytime("gc_numbymon_" ,mon)--按月份计算过车流量



local key = db_data.ip.."_enddata"
local ins_data = {}
ins_data[key] = cjson.encode(db_data1)
red_method.set_data(ins_data)

------返回正确代码
local tb_success = {}
tb_success.message = "upload is ok"
tb_success.vssid = db_data1.id
tb_success.code  = 200
ngx.say(cjson.encode(tb_success))


utils.gcs_log("info","pack is over")




















